--
-- PostgreSQL database dump
--

SET statement_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = off;
SET check_function_bodies = false;
SET client_min_messages = warning;
SET escape_string_warning = off;

--
-- Name: plpgsql; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: kinor
--

CREATE PROCEDURAL LANGUAGE plpgsql;


ALTER PROCEDURAL LANGUAGE plpgsql OWNER TO kinor;

SET search_path = public, pg_catalog;

--
-- Name: kinorez_rez_holder; Type: TYPE; Schema: public; Owner: kinor
--

CREATE TYPE kinorez_rez_holder AS (
	kiedy timestamp with time zone,
	id integer,
	id_klienta integer,
	id_instancji_miejsca integer,
	id_typu_biletu integer,
	opis text,
	cena_oryginalna numeric(10,3),
	cena_po_promocji numeric(10,3),
	rozpoczecie timestamp with time zone,
	tytul text
);


ALTER TYPE public.kinorez_rez_holder OWNER TO kinor;

--
-- Name: kinorez_widziane_filmy_holder; Type: TYPE; Schema: public; Owner: kinor
--

CREATE TYPE kinorez_widziane_filmy_holder AS (
	tytul text
);


ALTER TYPE public.kinorez_widziane_filmy_holder OWNER TO kinor;

--
-- Name: czas_przerwy_tech(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czas_przerwy_tech(id_sali integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN czas_przerwy_technicznej FROM kinorezerwacja_sala WHERE id = id_sali;
END; $$;


ALTER FUNCTION public.czas_przerwy_tech(id_sali integer) OWNER TO kinor;

--
-- Name: czas_rozpoczecia(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czas_rozpoczecia(id_seansu integer) RETURNS timestamp with time zone
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN rozpoczecie FROM kinorezerwacja_seans WHERE id = id_seansu;
END; $$;


ALTER FUNCTION public.czas_rozpoczecia(id_seansu integer) OWNER TO kinor;

--
-- Name: czas_trwania(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czas_trwania(id_filmu integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN czas_trwania FROM kinorezerwacja_film WHERE id = id_filmu;
END; $$;


ALTER FUNCTION public.czas_trwania(id_filmu integer) OWNER TO kinor;

--
-- Name: czy_jest_na_to_rezerwacja(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czy_jest_na_to_rezerwacja(tid_instancji_miejsca integer) RETURNS boolean
    LANGUAGE plpgsql
    AS $$ BEGIN
    RETURN (SELECT COUNT(*) FROM kinorezerwacja_rezerwacja WHERE id_instancji_miejsca = tid_instancji_miejsca) > 0;
END; $$;


ALTER FUNCTION public.czy_jest_na_to_rezerwacja(tid_instancji_miejsca integer) OWNER TO kinor;

--
-- Name: czy_przedzialy_sie_przecinaja(timestamp with time zone, timestamp with time zone, timestamp with time zone, timestamp with time zone); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czy_przedzialy_sie_przecinaja(beg1 timestamp with time zone, end1 timestamp with time zone, beg2 timestamp with time zone, end2 timestamp with time zone) RETURNS boolean
    LANGUAGE plpgsql
    AS $$
BEGIN
    -- beg1 <= beg2 < end1
    IF beg1 <= beg2 AND (end1 IS NULL OR end1 > beg2) THEN 
        RETURN TRUE;
    -- beg2 <= beg1 < end2
    ELSEIF beg2 <= beg1 AND (end2 IS NULL OR end2 > beg1) THEN 
        RETURN TRUE;
    ELSE 
        RETURN FALSE;
    END IF;
END; $$;


ALTER FUNCTION public.czy_przedzialy_sie_przecinaja(beg1 timestamp with time zone, end1 timestamp with time zone, beg2 timestamp with time zone, end2 timestamp with time zone) OWNER TO kinor;

--
-- Name: czy_sie_nie_pokrywaja(timestamp with time zone, integer, timestamp with time zone, integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czy_sie_nie_pokrywaja(rozp_pierw timestamp with time zone, czas_trw_pierw integer, rozp_drug timestamp with time zone, czas_przerwy integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    IF rozp_pierw + czas_trw_pierw * INTERVAL '1 MINUTE' 
        + czas_przerwy * INTERVAL '1 MINUTE' <= rozp_drug THEN
        RETURN 1;    
    ELSE RETURN 0;
    END IF;
END; $$;


ALTER FUNCTION public.czy_sie_nie_pokrywaja(rozp_pierw timestamp with time zone, czas_trw_pierw integer, rozp_drug timestamp with time zone, czas_przerwy integer) OWNER TO kinor;

--
-- Name: czy_uzytkownik_jest_adminem(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION czy_uzytkownik_jest_adminem(id_usera integer) RETURNS boolean
    LANGUAGE plpgsql
    AS $$
BEGIN
    IF (SELECT COUNT(*) FROM kinorezerwacja_ranga_klienta WHERE id_rangi = 1 AND id_klienta = id_usera) > 0 
        THEN RETURN TRUE;
    ELSE   
        RETURN FALSE;
    END IF;
END; $$;


ALTER FUNCTION public.czy_uzytkownik_jest_adminem(id_usera integer) OWNER TO kinor;

--
-- Name: dodaj_nowego_klienta(text, text, text, text); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION dodaj_nowego_klienta(mlogin text, mhaslo text, mimie text, mnazwisko text) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO kinorezerwacja_klient(login, haslo, imie, nazwisko) VALUES(mlogin, mhaslo, mimie, mnazwisko);
    INSERT INTO kinorezerwacja_ranga_klienta(id_rangi, id_klienta) VALUES(2, CURRVAL('kinorezerwacja_klient_id_seq'));
    RETURN CURRVAL('kinorezerwacja_klient_id_seq');
END; $$;


ALTER FUNCTION public.dodaj_nowego_klienta(mlogin text, mhaslo text, mimie text, mnazwisko text) OWNER TO kinor;

--
-- Name: dodaj_sale(integer, text, integer, integer, integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION dodaj_sale(mid_budynku integer, mopis text, mrzedow integer, mmiejsc_w_r integer, mczas_przerwy_technicznej integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO kinorezerwacja_sala(id_budynku, opis, czas_przerwy_technicznej) VALUES(mid_budynku, mopis, mczas_przerwy_technicznej);
    FOR i IN 1..mrzedow LOOP
        FOR j IN 1..mmiejsc_w_r LOOP
            INSERT INTO kinorezerwacja_miejsce(id_sali, rzad, miejsce) VALUES(CURRVAL('kinorezerwacja_sala_id_seq'), i, j);
        END LOOP;
    END LOOP;
    RETURN CURRVAL('kinorezerwacja_sala_id_seq');
END; $$;


ALTER FUNCTION public.dodaj_sale(mid_budynku integer, mopis text, mrzedow integer, mmiejsc_w_r integer, mczas_przerwy_technicznej integer) OWNER TO kinor;

--
-- Name: dodaj_seans(integer, integer, timestamp with time zone); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION dodaj_seans(mid_filmu integer, mid_sali integer, mrozpoczecie timestamp with time zone) RETURNS integer
    LANGUAGE plpgsql
    AS $$
DECLARE
    r kinorezerwacja_miejsce%rowtype;
    awaria_sali boolean;
BEGIN
    SELECT * INTO awaria_sali FROM 
        sprawdz_czy_cos_uleglo_awarii(mrozpoczecie, 
        mrozpoczecie + czas_trwania(mid_filmu) * INTERVAL '1 MINUTE', 
        mid_sali, 'sali');
    INSERT INTO kinorezerwacja_seans(id_filmu, id_sali, rozpoczecie) VALUES(mid_filmu, mid_sali, mrozpoczecie);
    for r in (
        SELECT * FROM kinorezerwacja_miejsce WHERE id_sali = mid_sali
    ) LOOP
        IF awaria_sali THEN 
            INSERT INTO kinorezerwacja_instancja_miejsca(id_miejsca, id_seansu, stan) 
            VALUES(r.id, CURRVAL('kinorezerwacja_seans_id_seq'), 'niedostepny');
        ELSEIF sprawdz_czy_cos_uleglo_awarii(mrozpoczecie, 
            mrozpoczecie + czas_trwania(mid_filmu) * INTERVAL '1 MINUTE', r.id, 'miejsca') THEN
            INSERT INTO kinorezerwacja_instancja_miejsca(id_miejsca, id_seansu, stan) 
            VALUES(r.id, CURRVAL('kinorezerwacja_seans_id_seq'), 'niedostepny');
        ELSE
            INSERT INTO kinorezerwacja_instancja_miejsca(id_miejsca, id_seansu, stan) 
            VALUES(r.id, CURRVAL('kinorezerwacja_seans_id_seq'), 'wolny');
        END IF;
        
    END LOOP;
    RETURN CURRVAL('kinorezerwacja_seans_id_seq');
END; $$;


ALTER FUNCTION public.dodaj_seans(mid_filmu integer, mid_sali integer, mrozpoczecie timestamp with time zone) OWNER TO kinor;

--
-- Name: ile_max_rezerwacji(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ile_max_rezerwacji(id_kli integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    IF czy_uzytkownik_jest_adminem(id_kli) THEN
        RETURN -1;
    END IF;
    RETURN COALESCE(MAX(kr_lim.limit), 0)
        FROM kinorezerwacja_limit_rezerwacji kr_lim
        JOIN kinorezerwacja_ranga kr_r ON kr_r.id = kr_lim.id_rangi
        JOIN kinorezerwacja_ranga_klienta kr_rk ON kr_rk.id_rangi = kr_r.id
        WHERE kr_rk.id_klienta = id_kli;
END; $$;


ALTER FUNCTION public.ile_max_rezerwacji(id_kli integer) OWNER TO kinor;

--
-- Name: ile_rezerwacji_aktualnie(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ile_rezerwacji_aktualnie(id_kli integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN COUNT(*) FROM podaj_rezerwacja_ktore_maja_status_rezerwowane(id_kli);
END; $$;


ALTER FUNCTION public.ile_rezerwacji_aktualnie(id_kli integer) OWNER TO kinor;

--
-- Name: kolejny_seans(timestamp with time zone, integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION kolejny_seans(czas_start timestamp with time zone, id_tej_sali integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN id FROM kinorezerwacja_seans WHERE id_sali = id_tej_sali AND rozpoczecie > czas_start ORDER BY rozpoczecie LIMIT 1;
END; $$;


ALTER FUNCTION public.kolejny_seans(czas_start timestamp with time zone, id_tej_sali integer) OWNER TO kinor;

--
-- Name: najlepsza_znizka(integer, character varying); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION najlepsza_znizka(id_rezerwacja integer, typ character varying) RETURNS integer
    LANGUAGE plpgsql
    AS $$
DECLARE
    tmp integer;
BEGIN
    SELECT max(znizka) INTO tmp
        FROM kinorezerwacja_promocja kr_p 
        CROSS JOIN kinorezerwacja_rezerwacja kr_r 
        JOIN kinorezerwacja_instancja_miejsca kr_im ON kr_r.id_instancji_miejsca = kr_im.id 
        JOIN kinorezerwacja_seans kr_s ON kr_im.id_seansu = kr_s.id
        CROSS JOIN kinorezerwacja_ranga_klienta kr_rk 
        WHERE kr_p.typ = typ
        AND kr_r.id = id_rezerwacja
        AND ((kr_rk.id_rangi = kr_p.id_rangi AND kr_rk.id_klienta = kr_r.id_klienta) OR kr_p.id_rangi = -1)
        AND kr_r.kiedy >= kr_p.od_rezerwacja
        AND (kr_p.do_rezerwacja IS NULL OR kr_p.do_rezerwacja >= kr_r.kiedy)
        AND kr_s.rozpoczecie >= kr_p.od_seans
        AND (kr_p.do_seans IS NULL OR kr_s.rozpoczecie <= kr_p.do_seans);
    IF tmp IS NULL THEN
        RETURN 0;
    ELSE
        RETURN tmp;
    END IF;     
END; $$;


ALTER FUNCTION public.najlepsza_znizka(id_rezerwacja integer, typ character varying) OWNER TO kinor;

--
-- Name: pobierz_id_filmu(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION pobierz_id_filmu(id_seansu integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN id_filmu FROM kinorezerwacja_seans WHERE id = id_seansu;
END; $$;


ALTER FUNCTION public.pobierz_id_filmu(id_seansu integer) OWNER TO kinor;

--
-- Name: pobierz_id_sali(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION pobierz_id_sali(id_miejsca integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN id_sali FROM kinorezerwacja_miejsce WHERE id = id_miejsca;
END; $$;


ALTER FUNCTION public.pobierz_id_sali(id_miejsca integer) OWNER TO kinor;

--
-- Name: podaj_filmy_rezerwowane(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION podaj_filmy_rezerwowane(id_kli integer) RETURNS SETOF kinorez_widziane_filmy_holder
    LANGUAGE plpgsql
    AS $$
DECLARE
    r kinorez_widziane_filmy_holder%rowtype;
BEGIN
    for r in (
        SELECT DISTINCT(kr_f.tytul)
        FROM kinorezerwacja_rezerwacja kr_r 
        JOIN kinorezerwacja_instancja_miejsca kr_im
            ON kr_im.id = kr_r.id_instancji_miejsca
        JOIN kinorezerwacja_seans kr_s
            ON kr_im.id_seansu = kr_s.id
        JOIN kinorezerwacja_film kr_f
            ON kr_s.id_filmu = kr_f.id
        WHERE kr_r.id_klienta = id_kli 
        ORDER BY kr_f.tytul
    ) LOOP
        RETURN NEXT r;
    END LOOP;
    RETURN;
END; $$;


ALTER FUNCTION public.podaj_filmy_rezerwowane(id_kli integer) OWNER TO kinor;

--
-- Name: podaj_najlepsza_cena(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION podaj_najlepsza_cena(id_rezerwacja integer) RETURNS numeric
    LANGUAGE plpgsql
    AS $$
DECLARE
    cena_org numeric(10,3);
    znizka_proc integer;
    znizka_stala integer;    
BEGIN  
    SELECT cena INTO cena_org
        FROM kinorezerwacja_rezerwacja kr_r JOIN kinorezerwacja_typ_biletu kr_tb ON kr_r.id_typu_biletu = kr_tb.id
        WHERE id_rezerwacja = kr_r.id;
    SELECT najlepsza_znizka(id_rezerwacja, 'procentowa') INTO znizka_proc;
    SELECT najlepsza_znizka(id_rezerwacja, 'stala') INTO znizka_stala;

    IF cena_org IS NULL THEN
        cena_org = 0;
    END IF;    
    IF ((cena_org - znizka_stala) < (cena_org * (100 - znizka_proc) / 100)) THEN
        IF (cena_org - znizka_stala < 1) THEN
            RETURN 1;
        ELSE
            RETURN cena_org - znizka_stala;
        END IF;         
    ELSE
        RETURN cena_org * (100 - znizka_proc) / 100;
    END IF;
        
END; $$;


ALTER FUNCTION public.podaj_najlepsza_cena(id_rezerwacja integer) OWNER TO kinor;

--
-- Name: podaj_rezerwacja(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION podaj_rezerwacja(id_kli integer) RETURNS SETOF kinorez_rez_holder
    LANGUAGE plpgsql
    AS $$
DECLARE
    r kinorez_rez_holder%rowtype;
BEGIN
    for r in (
        SELECT kr_r.kiedy, kr_r.id, kr_r.id_klienta, kr_r.id_instancji_miejsca, kr_r.id_typu_biletu, kr_tb.opis, kr_tb.cena, podaj_najlepsza_cena(kr_r.id), kr_s.rozpoczecie, kr_f.tytul
        FROM kinorezerwacja_rezerwacja kr_r 
        JOIN kinorezerwacja_typ_biletu kr_tb 
            ON kr_r.id_typu_biletu = kr_tb.id 
        JOIN kinorezerwacja_instancja_miejsca kr_im
            ON kr_im.id = kr_r.id_instancji_miejsca
        JOIN kinorezerwacja_seans kr_s
            ON kr_im.id_seansu = kr_s.id
        JOIN kinorezerwacja_film kr_f
            ON kr_s.id_filmu = kr_f.id
        WHERE kr_r.id_klienta = id_kli 
        ORDER BY kr_r.kiedy
    ) LOOP
        RETURN NEXT r;
    END LOOP;
    RETURN;
END; $$;


ALTER FUNCTION public.podaj_rezerwacja(id_kli integer) OWNER TO kinor;

--
-- Name: podaj_rezerwacja_ktore_maja_status_rezerwowane(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION podaj_rezerwacja_ktore_maja_status_rezerwowane(id_kli integer) RETURNS SETOF kinorez_rez_holder
    LANGUAGE plpgsql
    AS $$
DECLARE
    r kinorez_rez_holder%rowtype;
BEGIN
    for r in (
        SELECT * FROM podaj_rezerwacja(id_kli)
    ) LOOP
        IF (SELECT COUNT(*) FROM kinorezerwacja_instancja_miejsca kr_im 
        WHERE r.id_instancji_miejsca = kr_im.id AND stan = 'zarezerwowany' ) 
        > 0 THEN
            RETURN NEXT r;
        END IF;    
    END LOOP;
    RETURN;
END; $$;


ALTER FUNCTION public.podaj_rezerwacja_ktore_maja_status_rezerwowane(id_kli integer) OWNER TO kinor;

--
-- Name: poprzedni_seans(timestamp with time zone, integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION poprzedni_seans(czas_start timestamp with time zone, id_tej_sali integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN id FROM kinorezerwacja_seans WHERE id_sali = id_tej_sali AND rozpoczecie < czas_start ORDER BY rozpoczecie DESC LIMIT 1;
END; $$;


ALTER FUNCTION public.poprzedni_seans(czas_start timestamp with time zone, id_tej_sali integer) OWNER TO kinor;

--
-- Name: premiera_filmu(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION premiera_filmu(id_filmu integer) RETURNS timestamp with time zone
    LANGUAGE plpgsql
    AS $$
BEGIN
    RETURN premiera_w_polsce FROM kinorezerwacja_film WHERE id = id_filmu;
END; $$;


ALTER FUNCTION public.premiera_filmu(id_filmu integer) OWNER TO kinor;

--
-- Name: sprawdz_czy_awaria_ok(character varying, integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION sprawdz_czy_awaria_ok(czego character varying, id_obiektu integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    IF czego = 'sali' THEN RETURN COUNT(*) FROM kinorezerwacja_sala WHERE id = id_obiektu;
    ELSE RETURN COUNT(*) FROM kinorezerwacja_miejsce WHERE id = id_obiektu;
    END IF;
END; $$;


ALTER FUNCTION public.sprawdz_czy_awaria_ok(czego character varying, id_obiektu integer) OWNER TO kinor;

--
-- Name: sprawdz_czy_cos_uleglo_awarii(timestamp with time zone, timestamp with time zone, integer, text); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION sprawdz_czy_cos_uleglo_awarii(czas_od timestamp with time zone, czas_do timestamp with time zone, id_czegos integer, typ_czegos text) RETURNS boolean
    LANGUAGE plpgsql
    AS $$
BEGIN
    IF (SELECT COUNT(*) FROM kinorezerwacja_awaria kr_a 
        WHERE kr_a.czego = typ_czegos
        AND kr_a.id_obiektu = id_czegos
        AND czy_przedzialy_sie_przecinaja(kr_a.od, kr_a.do, czas_od, czas_do)
        ) > 0 THEN
            RETURN TRUE;
    ELSE RETURN FALSE;
    END IF;        
END; $$;


ALTER FUNCTION public.sprawdz_czy_cos_uleglo_awarii(czas_od timestamp with time zone, czas_do timestamp with time zone, id_czegos integer, typ_czegos text) OWNER TO kinor;

--
-- Name: ustaw_czas_awarii_zmiana(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ustaw_czas_awarii_zmiana() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
    BEGIN
        NEW.od = NEW.do;
        IF OLD.do IS NOT NULL THEN
            NEW.do = OLD.do;
        END IF;    
        RETURN NEW;
    END;
$$;


ALTER FUNCTION public.ustaw_czas_awarii_zmiana() OWNER TO kinor;

--
-- Name: ustaw_czas_poczatkowy_awarii(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ustaw_czas_poczatkowy_awarii() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
    BEGIN
        IF NEW.od < current_timestamp THEN
            NEW.od = current_timestamp;
        END IF;
        IF NEW.do IS NOT NULL AND NEW.do <= current_timestamp THEN
            NEW.do = current_timestamp + INTERVAL '1 MINUTE';
        END IF;    
        RETURN NEW;
    END;
$$;


ALTER FUNCTION public.ustaw_czas_poczatkowy_awarii() OWNER TO kinor;

--
-- Name: ustaw_nowy_stan(integer); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ustaw_nowy_stan(id_im integer) RETURNS void
    LANGUAGE plpgsql
    AS $$ BEGIN
     
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'wolny'
        WHERE id = id_im
        AND (czy_jest_na_to_rezerwacja(id) = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca') = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali') = FALSE)
        ;
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'zarezerwowany'
        WHERE id = id_im
        AND (czy_jest_na_to_rezerwacja(id) = TRUE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca') = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali') = FALSE)
        ;
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'niedostepny'
        WHERE id = id_im
        AND 
        (
        sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca')
        OR sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali')
        );        
    RETURN;
END; $$;


ALTER FUNCTION public.ustaw_nowy_stan(id_im integer) OWNER TO kinor;

--
-- Name: ustaw_nowy_stan_instancji_miejsca(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ustaw_nowy_stan_instancji_miejsca() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
    BEGIN
        PERFORM ustaw_nowy_stan(OLD.id_instancji_miejsca);
        RETURN OLD;
    END;
$$;


ALTER FUNCTION public.ustaw_nowy_stan_instancji_miejsca() OWNER TO kinor;

--
-- Name: ustaw_nowy_stan_instancji_miejsca_po_awari(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION ustaw_nowy_stan_instancji_miejsca_po_awari() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
    DECLARE 
        r kinorezerwacja_instancja_miejsca%rowtype;
    BEGIN
        for r in (
            SELECT * FROM kinorezerwacja_instancja_miejsca 
        ) LOOP
            PERFORM ustaw_nowy_stan(r.id);
        END LOOP;
        RETURN OLD;
    END;
$$;


ALTER FUNCTION public.ustaw_nowy_stan_instancji_miejsca_po_awari() OWNER TO kinor;

--
-- Name: wlacz_awarie(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION wlacz_awarie() RETURNS integer
    LANGUAGE plpgsql
    AS $$
BEGIN
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'niedostepny'
        WHERE 
        sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca')
        OR sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali')
        ;
    RETURN CURRVAL('kinorezerwacja_awaria_id_seq');    
END; $$;


ALTER FUNCTION public.wlacz_awarie() OWNER TO kinor;

--
-- Name: zakoncz_awarie(integer, timestamp with time zone); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION zakoncz_awarie(id_awari integer, zakonczenie timestamp with time zone) RETURNS void
    LANGUAGE plpgsql
    AS $$
DECLARE
    prev timestamp with time zone;
BEGIN
    SELECT kr_a.do INTO prev FROM kinorezerwacja_awaria kr_a WHERE id = id_awari;
    IF prev IS NOT NULL THEN
        RETURN;
    END IF;    
    UPDATE kinorezerwacja_awaria kr_a SET kr_a.do = zakonczenie
        WHERE id = id_awari;
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'wolny'
        WHERE stan = 'awaria'
        AND (czy_jest_na_to_rezerwacja(id) = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca') = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali') = FALSE)
        ;
    UPDATE kinorezerwacja_instancja_miejsca SET stan = 'zarezerwowany'
        WHERE stan = 'awaria'
        AND (czy_jest_na_to_rezerwacja(id) = TRUE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        id_miejsca, 'miejsca') = FALSE)
        AND (sprawdz_czy_cos_uleglo_awarii(
        czas_rozpoczecia(id_seansu), 
        czas_rozpoczecia(id_seansu) + (czas_trwania(pobierz_id_filmu(id_seansu)) * INTERVAL '1 MINUTE'),
        pobierz_id_sali(id_miejsca), 'sali') = FALSE)
        ;


    RETURN;       
END; $$;


ALTER FUNCTION public.zakoncz_awarie(id_awari integer, zakonczenie timestamp with time zone) OWNER TO kinor;

--
-- Name: zaniechaj_zmiany_czasu_trwania_filmu(); Type: FUNCTION; Schema: public; Owner: kinor
--

CREATE FUNCTION zaniechaj_zmiany_czasu_trwania_filmu() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
    BEGIN
        NEW.czas_trwania = OLD.czas_trwania;
        RETURN NEW;
    END;
$$;


ALTER FUNCTION public.zaniechaj_zmiany_czasu_trwania_filmu() OWNER TO kinor;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: auth_group; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_group (
    id integer NOT NULL,
    name character varying(80) NOT NULL
);


ALTER TABLE public.auth_group OWNER TO kinor;

--
-- Name: auth_group_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_group_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_group_id_seq OWNER TO kinor;

--
-- Name: auth_group_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_group_id_seq OWNED BY auth_group.id;


--
-- Name: auth_group_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_group_id_seq', 1, false);


--
-- Name: auth_group_permissions; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_group_permissions (
    id integer NOT NULL,
    group_id integer NOT NULL,
    permission_id integer NOT NULL
);


ALTER TABLE public.auth_group_permissions OWNER TO kinor;

--
-- Name: auth_group_permissions_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_group_permissions_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_group_permissions_id_seq OWNER TO kinor;

--
-- Name: auth_group_permissions_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_group_permissions_id_seq OWNED BY auth_group_permissions.id;


--
-- Name: auth_group_permissions_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_group_permissions_id_seq', 1, false);


--
-- Name: auth_message; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_message (
    id integer NOT NULL,
    user_id integer NOT NULL,
    message text NOT NULL
);


ALTER TABLE public.auth_message OWNER TO kinor;

--
-- Name: auth_message_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_message_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_message_id_seq OWNER TO kinor;

--
-- Name: auth_message_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_message_id_seq OWNED BY auth_message.id;


--
-- Name: auth_message_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_message_id_seq', 1, false);


--
-- Name: auth_permission; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_permission (
    id integer NOT NULL,
    name character varying(50) NOT NULL,
    content_type_id integer NOT NULL,
    codename character varying(100) NOT NULL
);


ALTER TABLE public.auth_permission OWNER TO kinor;

--
-- Name: auth_permission_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_permission_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_permission_id_seq OWNER TO kinor;

--
-- Name: auth_permission_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_permission_id_seq OWNED BY auth_permission.id;


--
-- Name: auth_permission_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_permission_id_seq', 69, true);


--
-- Name: auth_user; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_user (
    id integer NOT NULL,
    username character varying(30) NOT NULL,
    first_name character varying(30) NOT NULL,
    last_name character varying(30) NOT NULL,
    email character varying(75) NOT NULL,
    password character varying(128) NOT NULL,
    is_staff boolean NOT NULL,
    is_active boolean NOT NULL,
    is_superuser boolean NOT NULL,
    last_login timestamp with time zone NOT NULL,
    date_joined timestamp with time zone NOT NULL
);


ALTER TABLE public.auth_user OWNER TO kinor;

--
-- Name: auth_user_groups; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_user_groups (
    id integer NOT NULL,
    user_id integer NOT NULL,
    group_id integer NOT NULL
);


ALTER TABLE public.auth_user_groups OWNER TO kinor;

--
-- Name: auth_user_groups_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_user_groups_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_user_groups_id_seq OWNER TO kinor;

--
-- Name: auth_user_groups_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_user_groups_id_seq OWNED BY auth_user_groups.id;


--
-- Name: auth_user_groups_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_user_groups_id_seq', 1, false);


--
-- Name: auth_user_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_user_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_user_id_seq OWNER TO kinor;

--
-- Name: auth_user_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_user_id_seq OWNED BY auth_user.id;


--
-- Name: auth_user_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_user_id_seq', 1, true);


--
-- Name: auth_user_user_permissions; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE auth_user_user_permissions (
    id integer NOT NULL,
    user_id integer NOT NULL,
    permission_id integer NOT NULL
);


ALTER TABLE public.auth_user_user_permissions OWNER TO kinor;

--
-- Name: auth_user_user_permissions_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE auth_user_user_permissions_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.auth_user_user_permissions_id_seq OWNER TO kinor;

--
-- Name: auth_user_user_permissions_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE auth_user_user_permissions_id_seq OWNED BY auth_user_user_permissions.id;


--
-- Name: auth_user_user_permissions_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('auth_user_user_permissions_id_seq', 1, false);


--
-- Name: kinorezerwacja_seans; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_seans (
    id integer NOT NULL,
    id_filmu integer NOT NULL,
    id_sali integer NOT NULL,
    rozpoczecie timestamp with time zone NOT NULL,
    CONSTRAINT kinorezerwacja_seans_nie_zachodza_na_siebie CHECK ((((kolejny_seans(rozpoczecie, id_sali) IS NULL) OR (czy_sie_nie_pokrywaja(rozpoczecie, czas_trwania(id_filmu), czas_rozpoczecia(kolejny_seans(rozpoczecie, id_sali)), czas_przerwy_tech(id_sali)) = 1)) AND ((poprzedni_seans(rozpoczecie, id_sali) IS NULL) OR (czy_sie_nie_pokrywaja(czas_rozpoczecia(poprzedni_seans(rozpoczecie, id_sali)), czas_trwania(pobierz_id_filmu(poprzedni_seans(rozpoczecie, id_sali))), rozpoczecie, czas_przerwy_tech(id_sali)) = 1)))),
    CONSTRAINT kinorezerwacja_seans_po_premierze CHECK ((premiera_filmu(id_filmu) <= rozpoczecie))
);


ALTER TABLE public.kinorezerwacja_seans OWNER TO kinor;

--
-- Name: bliski_seans; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW bliski_seans AS
    SELECT s.id, s.id_filmu, s.id_sali, s.rozpoczecie FROM kinorezerwacja_seans s WHERE (((s.rozpoczecie - now()) < '7 days'::interval) AND (now() < (s.rozpoczecie + '1 day'::interval)));


ALTER TABLE public.bliski_seans OWNER TO kinor;

--
-- Name: django_admin_log; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE django_admin_log (
    id integer NOT NULL,
    action_time timestamp with time zone NOT NULL,
    user_id integer NOT NULL,
    content_type_id integer,
    object_id text,
    object_repr character varying(200) NOT NULL,
    action_flag smallint NOT NULL,
    change_message text NOT NULL,
    CONSTRAINT django_admin_log_action_flag_check CHECK ((action_flag >= 0))
);


ALTER TABLE public.django_admin_log OWNER TO kinor;

--
-- Name: django_admin_log_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE django_admin_log_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.django_admin_log_id_seq OWNER TO kinor;

--
-- Name: django_admin_log_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE django_admin_log_id_seq OWNED BY django_admin_log.id;


--
-- Name: django_admin_log_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('django_admin_log_id_seq', 1, true);


--
-- Name: django_content_type; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE django_content_type (
    id integer NOT NULL,
    name character varying(100) NOT NULL,
    app_label character varying(100) NOT NULL,
    model character varying(100) NOT NULL
);


ALTER TABLE public.django_content_type OWNER TO kinor;

--
-- Name: django_content_type_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE django_content_type_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.django_content_type_id_seq OWNER TO kinor;

--
-- Name: django_content_type_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE django_content_type_id_seq OWNED BY django_content_type.id;


--
-- Name: django_content_type_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('django_content_type_id_seq', 23, true);


--
-- Name: django_session; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE django_session (
    session_key character varying(40) NOT NULL,
    session_data text NOT NULL,
    expire_date timestamp with time zone NOT NULL
);


ALTER TABLE public.django_session OWNER TO kinor;

--
-- Name: django_site; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE django_site (
    id integer NOT NULL,
    domain character varying(100) NOT NULL,
    name character varying(50) NOT NULL
);


ALTER TABLE public.django_site OWNER TO kinor;

--
-- Name: django_site_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE django_site_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.django_site_id_seq OWNER TO kinor;

--
-- Name: django_site_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE django_site_id_seq OWNED BY django_site.id;


--
-- Name: django_site_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('django_site_id_seq', 1, true);


--
-- Name: kinorezerwacja_film; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_film (
    id integer NOT NULL,
    tytul text NOT NULL,
    rezyser text NOT NULL,
    aktorzy text NOT NULL,
    opis text NOT NULL,
    czas_trwania integer NOT NULL,
    premiera timestamp with time zone NOT NULL,
    premiera_w_polsce timestamp with time zone NOT NULL,
    CONSTRAINT kinorezerwacja_film_czas_trwania_dod CHECK ((czas_trwania >= 1)),
    CONSTRAINT kinorezerwacja_film_premiery_ok CHECK ((premiera_w_polsce >= premiera))
);


ALTER TABLE public.kinorezerwacja_film OWNER TO kinor;

--
-- Name: grany_film; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW grany_film AS
    SELECT f.id, f.tytul, f.rezyser, f.aktorzy, f.opis, f.czas_trwania, f.premiera, f.premiera_w_polsce FROM kinorezerwacja_film f WHERE (EXISTS (SELECT s.id, s.id_filmu, s.id_sali, s.rozpoczecie FROM bliski_seans s WHERE (f.id = s.id_filmu))) ORDER BY f.tytul;


ALTER TABLE public.grany_film OWNER TO kinor;

--
-- Name: kinorezerwacja_awaria; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_awaria (
    id integer NOT NULL,
    czego character varying(10) NOT NULL,
    id_obiektu integer NOT NULL,
    od timestamp with time zone NOT NULL,
    "do" timestamp with time zone,
    CONSTRAINT kinorezerwacja_awaria_czas_ok CHECK ((("do" IS NULL) OR ("do" > od))),
    CONSTRAINT kinorezerwacja_awaria_czego_klucz_ok CHECK ((sprawdz_czy_awaria_ok(czego, id_obiektu) > 0)),
    CONSTRAINT kinorezerwacja_awaria_czego_ok CHECK ((((czego)::text = 'sali'::text) OR ((czego)::text = 'miejsca'::text)))
);


ALTER TABLE public.kinorezerwacja_awaria OWNER TO kinor;

--
-- Name: kinorezerwacja_awaria_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_awaria_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_awaria_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_awaria_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_awaria_id_seq OWNED BY kinorezerwacja_awaria.id;


--
-- Name: kinorezerwacja_awaria_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_awaria_id_seq', 1, false);


--
-- Name: kinorezerwacja_budynek; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_budynek (
    id integer NOT NULL,
    adres text NOT NULL,
    kontakt text NOT NULL,
    opis text NOT NULL
);


ALTER TABLE public.kinorezerwacja_budynek OWNER TO kinor;

--
-- Name: kinorezerwacja_budynek_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_budynek_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_budynek_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_budynek_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_budynek_id_seq OWNED BY kinorezerwacja_budynek.id;


--
-- Name: kinorezerwacja_budynek_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_budynek_id_seq', 2, true);


--
-- Name: kinorezerwacja_film_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_film_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_film_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_film_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_film_id_seq OWNED BY kinorezerwacja_film.id;


--
-- Name: kinorezerwacja_film_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_film_id_seq', 3, true);


--
-- Name: kinorezerwacja_instancja_miejsca; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_instancja_miejsca (
    id integer NOT NULL,
    id_miejsca integer NOT NULL,
    id_seansu integer NOT NULL,
    stan character varying(20) NOT NULL,
    CONSTRAINT kinorezerwacja_inst_msc_stan_ok CHECK ((((((stan)::text = 'wolny'::text) OR ((stan)::text = 'zarezerwowany'::text)) OR ((stan)::text = 'kupiony'::text)) OR ((stan)::text = 'niedostepny'::text)))
);


ALTER TABLE public.kinorezerwacja_instancja_miejsca OWNER TO kinor;

--
-- Name: kinorezerwacja_instancja_miejsca_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_instancja_miejsca_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_instancja_miejsca_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_instancja_miejsca_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_instancja_miejsca_id_seq OWNED BY kinorezerwacja_instancja_miejsca.id;


--
-- Name: kinorezerwacja_instancja_miejsca_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_instancja_miejsca_id_seq', 166, true);


--
-- Name: kinorezerwacja_klient; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_klient (
    id integer NOT NULL,
    login text NOT NULL,
    haslo text NOT NULL,
    imie text NOT NULL,
    nazwisko text NOT NULL
);


ALTER TABLE public.kinorezerwacja_klient OWNER TO kinor;

--
-- Name: kinorezerwacja_klient_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_klient_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_klient_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_klient_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_klient_id_seq OWNED BY kinorezerwacja_klient.id;


--
-- Name: kinorezerwacja_klient_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_klient_id_seq', 4, true);


--
-- Name: kinorezerwacja_limit_rezerwacji; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_limit_rezerwacji (
    id integer NOT NULL,
    id_rangi integer NOT NULL,
    "limit" integer NOT NULL,
    CONSTRAINT kinorezerwacja_limit_r_ok CHECK (("limit" >= 1))
);


ALTER TABLE public.kinorezerwacja_limit_rezerwacji OWNER TO kinor;

--
-- Name: kinorezerwacja_limit_rezerwacji_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_limit_rezerwacji_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_limit_rezerwacji_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_limit_rezerwacji_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_limit_rezerwacji_id_seq OWNED BY kinorezerwacja_limit_rezerwacji.id;


--
-- Name: kinorezerwacja_limit_rezerwacji_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_limit_rezerwacji_id_seq', 3, true);


--
-- Name: kinorezerwacja_miejsce; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_miejsce (
    id integer NOT NULL,
    id_sali integer NOT NULL,
    rzad integer NOT NULL,
    miejsce integer NOT NULL,
    CONSTRAINT kinorezerwacja_miejsce_msc_ok CHECK ((miejsce >= 1)),
    CONSTRAINT kinorezerwacja_miejsce_rzad_ok CHECK ((rzad >= 1))
);


ALTER TABLE public.kinorezerwacja_miejsce OWNER TO kinor;

--
-- Name: kinorezerwacja_miejsce_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_miejsce_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_miejsce_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_miejsce_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_miejsce_id_seq OWNED BY kinorezerwacja_miejsce.id;


--
-- Name: kinorezerwacja_miejsce_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_miejsce_id_seq', 58, true);


--
-- Name: kinorezerwacja_mozliwy_bilet; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_mozliwy_bilet (
    id integer NOT NULL,
    id_typu integer NOT NULL,
    id_seansu integer NOT NULL
);


ALTER TABLE public.kinorezerwacja_mozliwy_bilet OWNER TO kinor;

--
-- Name: kinorezerwacja_mozliwy_bilet_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_mozliwy_bilet_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_mozliwy_bilet_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_mozliwy_bilet_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_mozliwy_bilet_id_seq OWNED BY kinorezerwacja_mozliwy_bilet.id;


--
-- Name: kinorezerwacja_mozliwy_bilet_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_mozliwy_bilet_id_seq', 22, true);


--
-- Name: kinorezerwacja_promocja; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_promocja (
    id integer NOT NULL,
    od_rezerwacja timestamp with time zone NOT NULL,
    do_rezerwacja timestamp with time zone,
    od_seans timestamp with time zone NOT NULL,
    do_seans timestamp with time zone,
    id_rangi integer NOT NULL,
    znizka integer NOT NULL,
    typ text NOT NULL,
    CONSTRAINT kinorezerwacja_promocja_czas_ok CHECK (((do_rezerwacja IS NULL) OR (do_rezerwacja >= od_rezerwacja))),
    CONSTRAINT kinorezerwacja_promocja_seanse_ok CHECK (((do_seans IS NULL) OR (do_seans >= od_seans))),
    CONSTRAINT kinorezerwacja_promocja_typ_ok CHECK (((typ = 'procentowa'::text) OR (typ = 'stala'::text))),
    CONSTRAINT kinorezerwacja_promocja_wart_ok CHECK ((((typ = 'stala'::text) AND (znizka > 0)) OR (((typ = 'procentowa'::text) AND (znizka > 0)) AND (znizka < 100))))
);


ALTER TABLE public.kinorezerwacja_promocja OWNER TO kinor;

--
-- Name: kinorezerwacja_promocja_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_promocja_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_promocja_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_promocja_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_promocja_id_seq OWNED BY kinorezerwacja_promocja.id;


--
-- Name: kinorezerwacja_promocja_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_promocja_id_seq', 5, true);


--
-- Name: kinorezerwacja_ranga; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_ranga (
    id integer NOT NULL,
    skrot text NOT NULL,
    opis text NOT NULL
);


ALTER TABLE public.kinorezerwacja_ranga OWNER TO kinor;

--
-- Name: kinorezerwacja_ranga_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_ranga_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_ranga_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_ranga_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_ranga_id_seq OWNED BY kinorezerwacja_ranga.id;


--
-- Name: kinorezerwacja_ranga_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_ranga_id_seq', 5, true);


--
-- Name: kinorezerwacja_ranga_klienta; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_ranga_klienta (
    id integer NOT NULL,
    id_rangi integer NOT NULL,
    id_klienta integer NOT NULL
);


ALTER TABLE public.kinorezerwacja_ranga_klienta OWNER TO kinor;

--
-- Name: kinorezerwacja_ranga_klienta_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_ranga_klienta_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_ranga_klienta_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_ranga_klienta_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_ranga_klienta_id_seq OWNED BY kinorezerwacja_ranga_klienta.id;


--
-- Name: kinorezerwacja_ranga_klienta_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_ranga_klienta_id_seq', 8, true);


--
-- Name: kinorezerwacja_rezerwacja; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_rezerwacja (
    id integer NOT NULL,
    id_klienta integer NOT NULL,
    id_instancji_miejsca integer NOT NULL,
    id_typu_biletu integer NOT NULL,
    kiedy timestamp with time zone NOT NULL,
    CONSTRAINT kinorezerwacja_rezerwacja_nie_przekroczony_limit CHECK (((ile_max_rezerwacji(id_klienta) = (-1)) OR (ile_max_rezerwacji(id_klienta) > ile_rezerwacji_aktualnie(id_klienta))))
);


ALTER TABLE public.kinorezerwacja_rezerwacja OWNER TO kinor;

--
-- Name: kinorezerwacja_rezerwacja_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_rezerwacja_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_rezerwacja_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_rezerwacja_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_rezerwacja_id_seq OWNED BY kinorezerwacja_rezerwacja.id;


--
-- Name: kinorezerwacja_rezerwacja_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_rezerwacja_id_seq', 3, true);


--
-- Name: kinorezerwacja_sala; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_sala (
    id integer NOT NULL,
    id_budynku integer NOT NULL,
    opis text NOT NULL,
    czas_przerwy_technicznej integer NOT NULL,
    CONSTRAINT kinorezerwacja_sala_przerwa_dod CHECK ((czas_przerwy_technicznej > 0))
);


ALTER TABLE public.kinorezerwacja_sala OWNER TO kinor;

--
-- Name: kinorezerwacja_sala_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_sala_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_sala_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_sala_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_sala_id_seq OWNED BY kinorezerwacja_sala.id;


--
-- Name: kinorezerwacja_sala_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_sala_id_seq', 4, true);


--
-- Name: kinorezerwacja_seans_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_seans_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_seans_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_seans_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_seans_id_seq OWNED BY kinorezerwacja_seans.id;


--
-- Name: kinorezerwacja_seans_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_seans_id_seq', 14, true);


--
-- Name: kinorezerwacja_typ_biletu; Type: TABLE; Schema: public; Owner: kinor; Tablespace: 
--

CREATE TABLE kinorezerwacja_typ_biletu (
    id integer NOT NULL,
    opis text NOT NULL,
    cena numeric(10,3) NOT NULL,
    CONSTRAINT kinorezerwacja_typ_bil_cena_dod CHECK ((cena > (0)::numeric))
);


ALTER TABLE public.kinorezerwacja_typ_biletu OWNER TO kinor;

--
-- Name: kinorezerwacja_typ_biletu_id_seq; Type: SEQUENCE; Schema: public; Owner: kinor
--

CREATE SEQUENCE kinorezerwacja_typ_biletu_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;


ALTER TABLE public.kinorezerwacja_typ_biletu_id_seq OWNER TO kinor;

--
-- Name: kinorezerwacja_typ_biletu_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: kinor
--

ALTER SEQUENCE kinorezerwacja_typ_biletu_id_seq OWNED BY kinorezerwacja_typ_biletu.id;


--
-- Name: kinorezerwacja_typ_biletu_id_seq; Type: SEQUENCE SET; Schema: public; Owner: kinor
--

SELECT pg_catalog.setval('kinorezerwacja_typ_biletu_id_seq', 5, true);


--
-- Name: miejsca; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW miejsca AS
    SELECT seans.id AS id_seansu, inst.id AS id_instancji_miejsca, m.miejsce, m.rzad, inst.stan, r.id_klienta, r.id AS id_rezerwacji FROM (((kinorezerwacja_seans seans JOIN kinorezerwacja_instancja_miejsca inst ON ((seans.id = inst.id_seansu))) JOIN kinorezerwacja_miejsce m ON ((inst.id_miejsca = m.id))) LEFT JOIN kinorezerwacja_rezerwacja r ON ((r.id_instancji_miejsca = inst.id))) ORDER BY m.rzad, m.miejsce;


ALTER TABLE public.miejsca OWNER TO kinor;

--
-- Name: ranga_limit; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW ranga_limit AS
    SELECT r.id, r.skrot, r.opis, l."limit" AS limit_rezerwacji, l.id AS id_limitu FROM (kinorezerwacja_ranga r LEFT JOIN kinorezerwacja_limit_rezerwacji l ON ((r.id = l.id_rangi)));


ALTER TABLE public.ranga_limit OWNER TO kinor;

--
-- Name: rezerwacja; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW rezerwacja AS
    SELECT r.kiedy, r.id, r.id_klienta, tb.opis AS opis_biletu, tb.cena, podaj_najlepsza_cena(r.id) AS cena_promocyjna, s.rozpoczecie, f.tytul, sala.opis AS opis_sali, miejsce.miejsce, miejsce.rzad, im.stan, f.id AS id_filmu, s.id AS id_seansu, im.id AS id_instancji_miejsca FROM ((((((kinorezerwacja_rezerwacja r JOIN kinorezerwacja_typ_biletu tb ON ((r.id_typu_biletu = tb.id))) JOIN kinorezerwacja_instancja_miejsca im ON ((im.id = r.id_instancji_miejsca))) JOIN kinorezerwacja_seans s ON ((im.id_seansu = s.id))) JOIN kinorezerwacja_film f ON ((s.id_filmu = f.id))) JOIN kinorezerwacja_miejsce miejsce ON ((im.id_miejsca = miejsce.id))) JOIN kinorezerwacja_sala sala ON ((miejsce.id_sali = sala.id))) ORDER BY r.kiedy;


ALTER TABLE public.rezerwacja OWNER TO kinor;

--
-- Name: rozklad; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW rozklad AS
    SELECT b.id AS id_budynku, b.adres, b.kontakt, b.opis, sala.id AS id_sali, sala.opis AS opis_sali, seans.rozpoczecie, f.id AS id_filmu, f.tytul, f.opis AS opis_filmu, f.czas_trwania, seans.id AS id_seansu FROM (((kinorezerwacja_budynek b LEFT JOIN kinorezerwacja_sala sala ON ((b.id = sala.id_budynku))) LEFT JOIN kinorezerwacja_seans seans ON ((seans.id_sali = sala.id))) LEFT JOIN kinorezerwacja_film f ON ((seans.id_filmu = f.id)));


ALTER TABLE public.rozklad OWNER TO kinor;

--
-- Name: seans_bilet; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW seans_bilet AS
    SELECT s.id AS id_seansu, b.id AS id_typu_biletu, b.opis, b.cena FROM ((kinorezerwacja_seans s JOIN kinorezerwacja_mozliwy_bilet mb ON ((s.id = mb.id_seansu))) JOIN kinorezerwacja_typ_biletu b ON ((b.id = mb.id_typu)));


ALTER TABLE public.seans_bilet OWNER TO kinor;

--
-- Name: seans_film; Type: VIEW; Schema: public; Owner: kinor
--

CREATE VIEW seans_film AS
    SELECT f.id AS id_filmu, f.tytul, f.rezyser, f.aktorzy, f.opis, f.czas_trwania, f.premiera, f.premiera_w_polsce, s.id AS id_seansu, s.id_sali, s.rozpoczecie FROM (kinorezerwacja_film f LEFT JOIN bliski_seans s ON ((f.id = s.id_filmu))) ORDER BY f.tytul, s.rozpoczecie;


ALTER TABLE public.seans_film OWNER TO kinor;

--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_group ALTER COLUMN id SET DEFAULT nextval('auth_group_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_group_permissions ALTER COLUMN id SET DEFAULT nextval('auth_group_permissions_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_message ALTER COLUMN id SET DEFAULT nextval('auth_message_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_permission ALTER COLUMN id SET DEFAULT nextval('auth_permission_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_user ALTER COLUMN id SET DEFAULT nextval('auth_user_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_user_groups ALTER COLUMN id SET DEFAULT nextval('auth_user_groups_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE auth_user_user_permissions ALTER COLUMN id SET DEFAULT nextval('auth_user_user_permissions_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE django_admin_log ALTER COLUMN id SET DEFAULT nextval('django_admin_log_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE django_content_type ALTER COLUMN id SET DEFAULT nextval('django_content_type_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE django_site ALTER COLUMN id SET DEFAULT nextval('django_site_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_awaria ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_awaria_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_budynek ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_budynek_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_film ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_film_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_instancja_miejsca ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_instancja_miejsca_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_klient ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_klient_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_limit_rezerwacji ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_limit_rezerwacji_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_miejsce ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_miejsce_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_mozliwy_bilet ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_mozliwy_bilet_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_promocja ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_promocja_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_ranga ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_ranga_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_ranga_klienta ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_ranga_klienta_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_rezerwacja ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_rezerwacja_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_sala ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_sala_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_seans ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_seans_id_seq'::regclass);


--
-- Name: id; Type: DEFAULT; Schema: public; Owner: kinor
--

ALTER TABLE kinorezerwacja_typ_biletu ALTER COLUMN id SET DEFAULT nextval('kinorezerwacja_typ_biletu_id_seq'::regclass);


--
-- Data for Name: auth_group; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_group (id, name) FROM stdin;
\.


--
-- Data for Name: auth_group_permissions; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_group_permissions (id, group_id, permission_id) FROM stdin;
\.


--
-- Data for Name: auth_message; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_message (id, user_id, message) FROM stdin;
\.


--
-- Data for Name: auth_permission; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_permission (id, name, content_type_id, codename) FROM stdin;
1	Can add permission	1	add_permission
2	Can change permission	1	change_permission
3	Can delete permission	1	delete_permission
4	Can add group	2	add_group
5	Can change group	2	change_group
6	Can delete group	2	delete_group
7	Can add user	3	add_user
8	Can change user	3	change_user
9	Can delete user	3	delete_user
10	Can add message	4	add_message
11	Can change message	4	change_message
12	Can delete message	4	delete_message
13	Can add content type	5	add_contenttype
14	Can change content type	5	change_contenttype
15	Can delete content type	5	delete_contenttype
16	Can add session	6	add_session
17	Can change session	6	change_session
18	Can delete session	6	delete_session
19	Can add site	7	add_site
20	Can change site	7	change_site
21	Can delete site	7	delete_site
22	Can add log entry	8	add_logentry
23	Can change log entry	8	change_logentry
24	Can delete log entry	8	delete_logentry
25	Can add budynek	9	add_budynek
26	Can change budynek	9	change_budynek
27	Can delete budynek	9	delete_budynek
28	Can add sala	10	add_sala
29	Can change sala	10	change_sala
30	Can delete sala	10	delete_sala
31	Can add film	11	add_film
32	Can change film	11	change_film
33	Can delete film	11	delete_film
34	Can add seans	12	add_seans
35	Can change seans	12	change_seans
36	Can delete seans	12	delete_seans
37	Can add miejsce	13	add_miejsce
38	Can change miejsce	13	change_miejsce
39	Can delete miejsce	13	delete_miejsce
40	Can add awaria	14	add_awaria
41	Can change awaria	14	change_awaria
42	Can delete awaria	14	delete_awaria
43	Can add instancja_miejsca	15	add_instancja_miejsca
44	Can change instancja_miejsca	15	change_instancja_miejsca
45	Can delete instancja_miejsca	15	delete_instancja_miejsca
46	Can add typ_biletu	16	add_typ_biletu
47	Can change typ_biletu	16	change_typ_biletu
48	Can delete typ_biletu	16	delete_typ_biletu
49	Can add mozliwy_bilet	17	add_mozliwy_bilet
50	Can change mozliwy_bilet	17	change_mozliwy_bilet
51	Can delete mozliwy_bilet	17	delete_mozliwy_bilet
52	Can add klient	18	add_klient
53	Can change klient	18	change_klient
54	Can delete klient	18	delete_klient
55	Can add ranga	19	add_ranga
56	Can change ranga	19	change_ranga
57	Can delete ranga	19	delete_ranga
58	Can add ranga_klienta	20	add_ranga_klienta
59	Can change ranga_klienta	20	change_ranga_klienta
60	Can delete ranga_klienta	20	delete_ranga_klienta
61	Can add limit_rezerwacji	21	add_limit_rezerwacji
62	Can change limit_rezerwacji	21	change_limit_rezerwacji
63	Can delete limit_rezerwacji	21	delete_limit_rezerwacji
64	Can add promocja	22	add_promocja
65	Can change promocja	22	change_promocja
66	Can delete promocja	22	delete_promocja
67	Can add rezerwacja	23	add_rezerwacja
68	Can change rezerwacja	23	change_rezerwacja
69	Can delete rezerwacja	23	delete_rezerwacja
\.


--
-- Data for Name: auth_user; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_user (id, username, first_name, last_name, email, password, is_staff, is_active, is_superuser, last_login, date_joined) FROM stdin;
1	admin			admin@admini.pl	sha1$22911$8ebf4f4939e845a550448db5dbe3ae4fec45e100	t	t	t	2011-01-24 09:21:24.994417+01	2011-01-24 09:21:19.093053+01
\.


--
-- Data for Name: auth_user_groups; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_user_groups (id, user_id, group_id) FROM stdin;
\.


--
-- Data for Name: auth_user_user_permissions; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY auth_user_user_permissions (id, user_id, permission_id) FROM stdin;
\.


--
-- Data for Name: django_admin_log; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY django_admin_log (id, action_time, user_id, content_type_id, object_id, object_repr, action_flag, change_message) FROM stdin;
1	2011-01-24 09:21:50.526649+01	1	11	1	Film object	2	Zmieniono czas_trwania
\.


--
-- Data for Name: django_content_type; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY django_content_type (id, name, app_label, model) FROM stdin;
1	permission	auth	permission
2	group	auth	group
3	user	auth	user
4	message	auth	message
5	content type	contenttypes	contenttype
6	session	sessions	session
7	site	sites	site
8	log entry	admin	logentry
9	budynek	kinorezerwacja	budynek
10	sala	kinorezerwacja	sala
11	film	kinorezerwacja	film
12	seans	kinorezerwacja	seans
13	miejsce	kinorezerwacja	miejsce
14	awaria	kinorezerwacja	awaria
15	instancja_miejsca	kinorezerwacja	instancja_miejsca
16	typ_biletu	kinorezerwacja	typ_biletu
17	mozliwy_bilet	kinorezerwacja	mozliwy_bilet
18	klient	kinorezerwacja	klient
19	ranga	kinorezerwacja	ranga
20	ranga_klienta	kinorezerwacja	ranga_klienta
21	limit_rezerwacji	kinorezerwacja	limit_rezerwacji
22	promocja	kinorezerwacja	promocja
23	rezerwacja	kinorezerwacja	rezerwacja
\.


--
-- Data for Name: django_session; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY django_session (session_key, session_data, expire_date) FROM stdin;
3fc6edd5910b95a39fff1776d2668e8c	gAJ9cQFVBnVzZXJJZHECSwJzLmQwMDJkMTQzZDc2NjcyOTM4YTQ4NjhiNmQ0MmQxN2I0\n	2011-02-05 11:11:23.65213+01
20b4fbfb0834dd51932f6097adbd7925	gAJ9cQFVBnVzZXJJZHECSwJzLmQwMDJkMTQzZDc2NjcyOTM4YTQ4NjhiNmQ0MmQxN2I0\n	2011-02-06 01:37:08.99271+01
9d6c594f4a5d06012b88fd580499f03d	gAJ9cQEoVRJfYXV0aF91c2VyX2JhY2tlbmRxAlUpZGphbmdvLmNvbnRyaWIuYXV0aC5iYWNrZW5k\ncy5Nb2RlbEJhY2tlbmRxA1UNX2F1dGhfdXNlcl9pZHEESwF1LmYwOGQ2NDVjY2VlOTk3YjdmNTQz\nOTk1NjliNTg0MzUz\n	2011-02-07 09:21:25.025637+01
\.


--
-- Data for Name: django_site; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY django_site (id, domain, name) FROM stdin;
1	example.com	example.com
\.


--
-- Data for Name: kinorezerwacja_awaria; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_awaria (id, czego, id_obiektu, od, "do") FROM stdin;
\.


--
-- Data for Name: kinorezerwacja_budynek; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_budynek (id, adres, kontakt, opis) FROM stdin;
1	Filmowa 123	tel. 666-777-888	KinoR Kino
2	Aktorska 17/a	tel. 123-666-123	KinoR Kino
\.


--
-- Data for Name: kinorezerwacja_film; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_film (id, tytul, rezyser, aktorzy, opis, czas_trwania, premiera, premiera_w_polsce) FROM stdin;
2	Season of the Witch	Dominic Sena	Nicolas Cage, Ron Perlman	Epickie sceny bitewne w samym sercu brutalnego średniowiecza.	113	2011-01-06 00:00:00+01	2011-01-14 00:00:00+01
3	Inception	Christopher Nolan	Leonardo DiCaprio, Joseph Gordon-Levitt, Ellen Page	Jakaś zabawy z myślami i snami.	143	2010-06-08 00:00:00+02	2010-06-30 00:00:00+02
1	Black Swan	Darren Aronafsky	Natalie Portman	Film o baletnicach	110	2010-09-01 00:00:00+02	2011-01-21 00:00:00+01
\.


--
-- Data for Name: kinorezerwacja_instancja_miejsca; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_instancja_miejsca (id, id_miejsca, id_seansu, stan) FROM stdin;
2	2	1	wolny
3	3	1	wolny
4	4	1	wolny
5	5	1	wolny
6	6	1	wolny
7	7	1	wolny
8	8	1	wolny
9	9	2	wolny
10	10	2	wolny
11	11	2	wolny
12	12	2	wolny
13	13	2	wolny
14	14	2	wolny
15	15	2	wolny
16	16	2	wolny
17	17	2	wolny
18	18	2	wolny
19	19	2	wolny
20	20	2	wolny
21	21	2	wolny
22	22	2	wolny
23	23	2	wolny
24	24	2	wolny
25	25	2	wolny
26	26	2	wolny
27	27	2	wolny
28	28	2	wolny
29	29	2	wolny
30	30	2	wolny
31	31	2	wolny
32	32	2	wolny
1	1	1	zarezerwowany
33	41	3	wolny
34	42	3	wolny
37	45	3	wolny
38	46	3	wolny
39	47	3	wolny
40	48	3	wolny
41	49	3	wolny
42	50	3	wolny
43	51	3	wolny
44	52	3	wolny
45	53	3	wolny
46	54	3	wolny
47	55	3	wolny
48	56	3	wolny
49	57	3	wolny
50	58	3	wolny
35	43	3	zarezerwowany
36	44	3	zarezerwowany
51	41	4	wolny
52	42	4	wolny
53	43	4	wolny
54	44	4	wolny
55	45	4	wolny
56	46	4	wolny
57	47	4	wolny
58	48	4	wolny
59	49	4	wolny
60	50	4	wolny
61	51	4	wolny
62	52	4	wolny
63	53	4	wolny
64	54	4	wolny
65	55	4	wolny
66	56	4	wolny
67	57	4	wolny
68	58	4	wolny
69	41	6	wolny
70	42	6	wolny
71	43	6	wolny
72	44	6	wolny
73	45	6	wolny
74	46	6	wolny
75	47	6	wolny
76	48	6	wolny
77	49	6	wolny
78	50	6	wolny
79	51	6	wolny
80	52	6	wolny
81	53	6	wolny
82	54	6	wolny
83	55	6	wolny
84	56	6	wolny
85	57	6	wolny
86	58	6	wolny
87	9	7	wolny
88	10	7	wolny
89	11	7	wolny
90	12	7	wolny
91	13	7	wolny
92	14	7	wolny
93	15	7	wolny
94	16	7	wolny
95	17	7	wolny
96	18	7	wolny
97	19	7	wolny
98	20	7	wolny
99	21	7	wolny
100	22	7	wolny
101	23	7	wolny
102	24	7	wolny
103	25	7	wolny
104	26	7	wolny
105	27	7	wolny
106	28	7	wolny
107	29	7	wolny
108	30	7	wolny
109	31	7	wolny
110	32	7	wolny
111	9	10	wolny
112	10	10	wolny
113	11	10	wolny
114	12	10	wolny
115	13	10	wolny
116	14	10	wolny
117	15	10	wolny
118	16	10	wolny
119	17	10	wolny
120	18	10	wolny
121	19	10	wolny
122	20	10	wolny
123	21	10	wolny
124	22	10	wolny
125	23	10	wolny
126	24	10	wolny
127	25	10	wolny
128	26	10	wolny
129	27	10	wolny
130	28	10	wolny
131	29	10	wolny
132	30	10	wolny
133	31	10	wolny
134	32	10	wolny
135	1	11	wolny
136	2	11	wolny
137	3	11	wolny
138	4	11	wolny
139	5	11	wolny
140	6	11	wolny
141	7	11	wolny
142	8	11	wolny
143	1	12	wolny
144	2	12	wolny
145	3	12	wolny
146	4	12	wolny
147	5	12	wolny
148	6	12	wolny
149	7	12	wolny
150	8	12	wolny
151	33	13	wolny
152	34	13	wolny
153	35	13	wolny
154	36	13	wolny
155	37	13	wolny
156	38	13	wolny
157	39	13	wolny
158	40	13	wolny
159	33	14	wolny
160	34	14	wolny
161	35	14	wolny
162	36	14	wolny
163	37	14	wolny
164	38	14	wolny
165	39	14	wolny
166	40	14	wolny
\.


--
-- Data for Name: kinorezerwacja_klient; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_klient (id, login, haslo, imie, nazwisko) FROM stdin;
2	admin	admin	Admin	Admiński
3	emes	emes	Michał	Sapalski
1	dorota	dorota	Dorota	Wąs
4	lama	lama	Ruczajnik LOL	Jamnik
\.


--
-- Data for Name: kinorezerwacja_limit_rezerwacji; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_limit_rezerwacji (id, id_rangi, "limit") FROM stdin;
1	2	5
2	4	1000
3	5	100
\.


--
-- Data for Name: kinorezerwacja_miejsce; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_miejsce (id, id_sali, rzad, miejsce) FROM stdin;
1	1	1	1
2	1	1	2
3	1	1	3
4	1	1	4
5	1	2	1
6	1	2	2
7	1	2	3
8	1	2	4
9	2	1	1
10	2	1	2
11	2	1	3
12	2	1	4
13	2	1	5
14	2	1	6
15	2	2	1
16	2	2	2
17	2	2	3
18	2	2	4
19	2	2	5
20	2	2	6
21	2	3	1
22	2	3	2
23	2	3	3
24	2	3	4
25	2	3	5
26	2	3	6
27	2	4	1
28	2	4	2
29	2	4	3
30	2	4	4
31	2	4	5
32	2	4	6
33	3	1	1
34	3	1	2
35	3	1	3
36	3	1	4
37	3	1	5
38	3	1	6
39	3	1	7
40	3	1	8
41	4	1	1
42	4	1	2
43	4	1	3
44	4	1	4
45	4	1	5
46	4	1	6
47	4	2	1
48	4	2	2
49	4	2	3
50	4	2	4
51	4	2	5
52	4	2	6
53	4	3	1
54	4	3	2
55	4	3	3
56	4	3	4
57	4	3	5
58	4	3	6
\.


--
-- Data for Name: kinorezerwacja_mozliwy_bilet; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_mozliwy_bilet (id, id_typu, id_seansu) FROM stdin;
1	1	1
2	1	3
3	1	4
4	2	4
5	3	4
6	2	6
7	3	6
8	4	7
9	5	7
10	2	10
11	3	10
12	1	11
13	2	11
14	3	11
15	4	11
16	5	11
17	2	12
18	3	12
19	2	13
20	3	13
21	2	14
22	3	14
\.


--
-- Data for Name: kinorezerwacja_promocja; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_promocja (id, od_rezerwacja, do_rezerwacja, od_seans, do_seans, id_rangi, znizka, typ) FROM stdin;
1	2011-01-09 00:00:00+01	2011-01-11 00:00:00+01	2011-01-18 00:00:00+01	\N	-1	10	procentowa
2	2011-01-09 00:00:00+01	2011-01-11 00:00:00+01	2011-01-18 00:00:00+01	\N	3	20	stala
3	2011-01-09 00:00:00+01	2011-01-11 00:00:00+01	2011-01-18 00:00:00+01	2011-01-19 00:00:00+01	-1	25	stala
4	2011-01-01 00:00:00+01	2011-01-30 00:00:00+01	2011-01-01 00:00:00+01	2011-01-30 00:00:00+01	5	90	procentowa
5	2011-01-01 00:00:00+01	2011-01-30 00:00:00+01	2011-01-01 00:00:00+01	2011-03-30 00:00:00+02	4	100	stala
\.


--
-- Data for Name: kinorezerwacja_ranga; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_ranga (id, skrot, opis) FROM stdin;
1	Admin	Ranga admina
2	n00b	Ranga newbie
4	VIP	Fajna ranga którą każdy by chciał mieć. :)
5	Stali klienci.	Ranga dla stalych klientow.
\.


--
-- Data for Name: kinorezerwacja_ranga_klienta; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_ranga_klienta (id, id_rangi, id_klienta) FROM stdin;
1	1	2
5	5	3
6	4	1
8	2	4
\.


--
-- Data for Name: kinorezerwacja_rezerwacja; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_rezerwacja (id, id_klienta, id_instancji_miejsca, id_typu_biletu, kiedy) FROM stdin;
1	1	1	1	2011-01-10 00:00:00+01
2	3	35	1	2011-01-23 01:36:51.73674+01
3	3	36	1	2011-01-23 01:36:52.946365+01
\.


--
-- Data for Name: kinorezerwacja_sala; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_sala (id, id_budynku, opis, czas_przerwy_technicznej) FROM stdin;
1	1	Mala sala Filmowa	10
2	1	Duza sala Filmowa	30
3	2	Mala sala Aktorskiej	10
4	2	Duza sala Aktorskiej	20
\.


--
-- Data for Name: kinorezerwacja_seans; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_seans (id, id_filmu, id_sali, rozpoczecie) FROM stdin;
1	1	1	2011-01-22 18:30:00+01
2	1	2	2011-01-21 22:15:00+01
3	3	4	2011-01-25 00:14:00+01
4	1	4	2011-01-25 16:30:00+01
6	1	4	2011-01-25 19:30:00+01
7	1	2	2011-01-25 18:30:00+01
10	2	2	2011-01-25 16:00:00+01
11	3	1	2011-01-28 19:00:00+01
12	3	1	2011-01-27 19:00:00+01
13	3	3	2011-01-26 19:00:00+01
14	3	3	2011-01-29 19:00:00+01
\.


--
-- Data for Name: kinorezerwacja_typ_biletu; Type: TABLE DATA; Schema: public; Owner: kinor
--

COPY kinorezerwacja_typ_biletu (id, opis, cena) FROM stdin;
1	dla leszczy	50.000
2	Normalny	25.000
3	Ulgowy	13.000
4	Normalny 3D	39.000
5	Ulgowy 3D	19.000
\.


--
-- Name: auth_group_name_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_group
    ADD CONSTRAINT auth_group_name_key UNIQUE (name);


--
-- Name: auth_group_permissions_group_id_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_group_permissions
    ADD CONSTRAINT auth_group_permissions_group_id_key UNIQUE (group_id, permission_id);


--
-- Name: auth_group_permissions_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_group_permissions
    ADD CONSTRAINT auth_group_permissions_pkey PRIMARY KEY (id);


--
-- Name: auth_group_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_group
    ADD CONSTRAINT auth_group_pkey PRIMARY KEY (id);


--
-- Name: auth_message_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_message
    ADD CONSTRAINT auth_message_pkey PRIMARY KEY (id);


--
-- Name: auth_permission_content_type_id_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_permission
    ADD CONSTRAINT auth_permission_content_type_id_key UNIQUE (content_type_id, codename);


--
-- Name: auth_permission_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_permission
    ADD CONSTRAINT auth_permission_pkey PRIMARY KEY (id);


--
-- Name: auth_user_groups_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user_groups
    ADD CONSTRAINT auth_user_groups_pkey PRIMARY KEY (id);


--
-- Name: auth_user_groups_user_id_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user_groups
    ADD CONSTRAINT auth_user_groups_user_id_key UNIQUE (user_id, group_id);


--
-- Name: auth_user_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user
    ADD CONSTRAINT auth_user_pkey PRIMARY KEY (id);


--
-- Name: auth_user_user_permissions_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user_user_permissions
    ADD CONSTRAINT auth_user_user_permissions_pkey PRIMARY KEY (id);


--
-- Name: auth_user_user_permissions_user_id_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user_user_permissions
    ADD CONSTRAINT auth_user_user_permissions_user_id_key UNIQUE (user_id, permission_id);


--
-- Name: auth_user_username_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY auth_user
    ADD CONSTRAINT auth_user_username_key UNIQUE (username);


--
-- Name: django_admin_log_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY django_admin_log
    ADD CONSTRAINT django_admin_log_pkey PRIMARY KEY (id);


--
-- Name: django_content_type_app_label_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY django_content_type
    ADD CONSTRAINT django_content_type_app_label_key UNIQUE (app_label, model);


--
-- Name: django_content_type_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY django_content_type
    ADD CONSTRAINT django_content_type_pkey PRIMARY KEY (id);


--
-- Name: django_session_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY django_session
    ADD CONSTRAINT django_session_pkey PRIMARY KEY (session_key);


--
-- Name: django_site_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY django_site
    ADD CONSTRAINT django_site_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_awaria_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_awaria
    ADD CONSTRAINT kinorezerwacja_awaria_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_budynek_adres_unique; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_budynek
    ADD CONSTRAINT kinorezerwacja_budynek_adres_unique UNIQUE (adres);


--
-- Name: kinorezerwacja_budynek_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_budynek
    ADD CONSTRAINT kinorezerwacja_budynek_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_film_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_film
    ADD CONSTRAINT kinorezerwacja_film_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_film_tytul_unique; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_film
    ADD CONSTRAINT kinorezerwacja_film_tytul_unique UNIQUE (tytul);


--
-- Name: kinorezerwacja_instancja_miejsca_jedna_instancja_na_seans; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_instancja_miejsca
    ADD CONSTRAINT kinorezerwacja_instancja_miejsca_jedna_instancja_na_seans UNIQUE (id_miejsca, id_seansu);


--
-- Name: kinorezerwacja_instancja_miejsca_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_instancja_miejsca
    ADD CONSTRAINT kinorezerwacja_instancja_miejsca_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_klient_const_unique_login; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_klient
    ADD CONSTRAINT kinorezerwacja_klient_const_unique_login UNIQUE (login);


--
-- Name: kinorezerwacja_klient_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_klient
    ADD CONSTRAINT kinorezerwacja_klient_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_limit_rezerwacji_jedna_dla_rangi; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_limit_rezerwacji
    ADD CONSTRAINT kinorezerwacja_limit_rezerwacji_jedna_dla_rangi UNIQUE (id_rangi);


--
-- Name: kinorezerwacja_limit_rezerwacji_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_limit_rezerwacji
    ADD CONSTRAINT kinorezerwacja_limit_rezerwacji_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_maks_jedna_rezerwacja_na_miejsce; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_rezerwacja
    ADD CONSTRAINT kinorezerwacja_maks_jedna_rezerwacja_na_miejsce UNIQUE (id_instancji_miejsca);


--
-- Name: kinorezerwacja_miejsce_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_miejsce
    ADD CONSTRAINT kinorezerwacja_miejsce_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_mozliwy_bilet_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_mozliwy_bilet
    ADD CONSTRAINT kinorezerwacja_mozliwy_bilet_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_mozliwy_bilet_unique; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_mozliwy_bilet
    ADD CONSTRAINT kinorezerwacja_mozliwy_bilet_unique UNIQUE (id_typu, id_seansu);


--
-- Name: kinorezerwacja_msc_const_unique_rzad_msc; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_miejsce
    ADD CONSTRAINT kinorezerwacja_msc_const_unique_rzad_msc UNIQUE (id_sali, rzad, miejsce);


--
-- Name: kinorezerwacja_promocja_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_promocja
    ADD CONSTRAINT kinorezerwacja_promocja_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_ranga_klienta_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_ranga_klienta
    ADD CONSTRAINT kinorezerwacja_ranga_klienta_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_ranga_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_ranga
    ADD CONSTRAINT kinorezerwacja_ranga_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_ranga_skrot_key; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_ranga
    ADD CONSTRAINT kinorezerwacja_ranga_skrot_key UNIQUE (skrot);


--
-- Name: kinorezerwacja_ranga_unique; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_ranga
    ADD CONSTRAINT kinorezerwacja_ranga_unique UNIQUE (skrot);


--
-- Name: kinorezerwacja_rezerwacja_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_rezerwacja
    ADD CONSTRAINT kinorezerwacja_rezerwacja_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_sala_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_sala
    ADD CONSTRAINT kinorezerwacja_sala_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_seans_jeden_film_na_raz; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_seans
    ADD CONSTRAINT kinorezerwacja_seans_jeden_film_na_raz UNIQUE (id_sali, rozpoczecie);


--
-- Name: kinorezerwacja_seans_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_seans
    ADD CONSTRAINT kinorezerwacja_seans_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_typ_biletu_pkey; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_typ_biletu
    ADD CONSTRAINT kinorezerwacja_typ_biletu_pkey PRIMARY KEY (id);


--
-- Name: kinorezerwacja_typ_biletu_unique; Type: CONSTRAINT; Schema: public; Owner: kinor; Tablespace: 
--

ALTER TABLE ONLY kinorezerwacja_typ_biletu
    ADD CONSTRAINT kinorezerwacja_typ_biletu_unique UNIQUE (opis);


--
-- Name: auth_group_permissions_group_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_group_permissions_group_id ON auth_group_permissions USING btree (group_id);


--
-- Name: auth_group_permissions_permission_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_group_permissions_permission_id ON auth_group_permissions USING btree (permission_id);


--
-- Name: auth_message_user_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_message_user_id ON auth_message USING btree (user_id);


--
-- Name: auth_permission_content_type_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_permission_content_type_id ON auth_permission USING btree (content_type_id);


--
-- Name: auth_user_groups_group_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_user_groups_group_id ON auth_user_groups USING btree (group_id);


--
-- Name: auth_user_groups_user_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_user_groups_user_id ON auth_user_groups USING btree (user_id);


--
-- Name: auth_user_user_permissions_permission_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_user_user_permissions_permission_id ON auth_user_user_permissions USING btree (permission_id);


--
-- Name: auth_user_user_permissions_user_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX auth_user_user_permissions_user_id ON auth_user_user_permissions USING btree (user_id);


--
-- Name: django_admin_log_content_type_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX django_admin_log_content_type_id ON django_admin_log USING btree (content_type_id);


--
-- Name: django_admin_log_user_id; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX django_admin_log_user_id ON django_admin_log USING btree (user_id);


--
-- Name: kinorezerwacja_instancja_miejsca_id_miejsca; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_instancja_miejsca_id_miejsca ON kinorezerwacja_instancja_miejsca USING btree (id_miejsca);


--
-- Name: kinorezerwacja_instancja_miejsca_id_seansu; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_instancja_miejsca_id_seansu ON kinorezerwacja_instancja_miejsca USING btree (id_seansu);


--
-- Name: kinorezerwacja_limit_rezerwacji_id_rangi; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_limit_rezerwacji_id_rangi ON kinorezerwacja_limit_rezerwacji USING btree (id_rangi);


--
-- Name: kinorezerwacja_miejsce_id_sali; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_miejsce_id_sali ON kinorezerwacja_miejsce USING btree (id_sali);


--
-- Name: kinorezerwacja_mozliwy_bilet_id_seansu; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_mozliwy_bilet_id_seansu ON kinorezerwacja_mozliwy_bilet USING btree (id_seansu);


--
-- Name: kinorezerwacja_mozliwy_bilet_id_typu; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_mozliwy_bilet_id_typu ON kinorezerwacja_mozliwy_bilet USING btree (id_typu);


--
-- Name: kinorezerwacja_ranga_klienta_id_klienta; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_ranga_klienta_id_klienta ON kinorezerwacja_ranga_klienta USING btree (id_klienta);


--
-- Name: kinorezerwacja_ranga_klienta_id_rangi; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_ranga_klienta_id_rangi ON kinorezerwacja_ranga_klienta USING btree (id_rangi);


--
-- Name: kinorezerwacja_rezerwacja_id_instancji_miejsca; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_rezerwacja_id_instancji_miejsca ON kinorezerwacja_rezerwacja USING btree (id_instancji_miejsca);


--
-- Name: kinorezerwacja_rezerwacja_id_klienta; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_rezerwacja_id_klienta ON kinorezerwacja_rezerwacja USING btree (id_klienta);


--
-- Name: kinorezerwacja_rezerwacja_id_typu_biletu; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_rezerwacja_id_typu_biletu ON kinorezerwacja_rezerwacja USING btree (id_typu_biletu);


--
-- Name: kinorezerwacja_sala_id_budynku; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_sala_id_budynku ON kinorezerwacja_sala USING btree (id_budynku);


--
-- Name: kinorezerwacja_seans_id_filmu; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_seans_id_filmu ON kinorezerwacja_seans USING btree (id_filmu);


--
-- Name: kinorezerwacja_seans_id_sali; Type: INDEX; Schema: public; Owner: kinor; Tablespace: 
--

CREATE INDEX kinorezerwacja_seans_id_sali ON kinorezerwacja_seans USING btree (id_sali);


--
-- Name: awaria_rule_insert; Type: RULE; Schema: public; Owner: kinor
--

CREATE RULE awaria_rule_insert AS ON INSERT TO kinorezerwacja_awaria DO SELECT wlacz_awarie() AS wlacz_awarie;


--
-- Name: rezerwacja_rule_delete; Type: RULE; Schema: public; Owner: kinor
--

CREATE RULE rezerwacja_rule_delete AS ON DELETE TO kinorezerwacja_rezerwacja DO NOTHING;


--
-- Name: rezerwacja_rule_insert; Type: RULE; Schema: public; Owner: kinor
--

CREATE RULE rezerwacja_rule_insert AS ON INSERT TO kinorezerwacja_rezerwacja DO UPDATE kinorezerwacja_instancja_miejsca SET stan = 'zarezerwowany'::character varying WHERE ((kinorezerwacja_instancja_miejsca.id = new.id_instancji_miejsca) AND ((kinorezerwacja_instancja_miejsca.stan)::text = 'wolny'::text));


--
-- Name: ustaw_czas_awarii_zmiana; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER ustaw_czas_awarii_zmiana
    BEFORE UPDATE ON kinorezerwacja_awaria
    FOR EACH ROW
    EXECUTE PROCEDURE ustaw_czas_awarii_zmiana();


--
-- Name: ustaw_czas_poczatkowy_awarii; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER ustaw_czas_poczatkowy_awarii
    BEFORE INSERT ON kinorezerwacja_awaria
    FOR EACH ROW
    EXECUTE PROCEDURE ustaw_czas_poczatkowy_awarii();


--
-- Name: ustaw_nowy_stan_instancji_miejsca; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER ustaw_nowy_stan_instancji_miejsca
    AFTER DELETE ON kinorezerwacja_rezerwacja
    FOR EACH ROW
    EXECUTE PROCEDURE ustaw_nowy_stan_instancji_miejsca();


--
-- Name: ustaw_nowy_stan_instancji_miejsca_po_awarii; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER ustaw_nowy_stan_instancji_miejsca_po_awarii
    AFTER UPDATE ON kinorezerwacja_awaria
    FOR EACH ROW
    EXECUTE PROCEDURE ustaw_nowy_stan_instancji_miejsca_po_awari();


--
-- Name: uustaw_czas_awarii_zmiana; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER uustaw_czas_awarii_zmiana
    BEFORE UPDATE ON kinorezerwacja_awaria
    FOR EACH ROW
    EXECUTE PROCEDURE ustaw_czas_awarii_zmiana();


--
-- Name: zaniechaj_zmiany_czasu_trwania_filmu; Type: TRIGGER; Schema: public; Owner: kinor
--

CREATE TRIGGER zaniechaj_zmiany_czasu_trwania_filmu
    BEFORE UPDATE ON kinorezerwacja_film
    FOR EACH ROW
    EXECUTE PROCEDURE zaniechaj_zmiany_czasu_trwania_filmu();


--
-- Name: auth_group_permissions_permission_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_group_permissions
    ADD CONSTRAINT auth_group_permissions_permission_id_fkey FOREIGN KEY (permission_id) REFERENCES auth_permission(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: auth_message_user_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_message
    ADD CONSTRAINT auth_message_user_id_fkey FOREIGN KEY (user_id) REFERENCES auth_user(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: auth_user_groups_group_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_user_groups
    ADD CONSTRAINT auth_user_groups_group_id_fkey FOREIGN KEY (group_id) REFERENCES auth_group(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: auth_user_user_permissions_permission_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_user_user_permissions
    ADD CONSTRAINT auth_user_user_permissions_permission_id_fkey FOREIGN KEY (permission_id) REFERENCES auth_permission(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: content_type_id_refs_id_728de91f; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_permission
    ADD CONSTRAINT content_type_id_refs_id_728de91f FOREIGN KEY (content_type_id) REFERENCES django_content_type(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: django_admin_log_content_type_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY django_admin_log
    ADD CONSTRAINT django_admin_log_content_type_id_fkey FOREIGN KEY (content_type_id) REFERENCES django_content_type(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: django_admin_log_user_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY django_admin_log
    ADD CONSTRAINT django_admin_log_user_id_fkey FOREIGN KEY (user_id) REFERENCES auth_user(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: group_id_refs_id_3cea63fe; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_group_permissions
    ADD CONSTRAINT group_id_refs_id_3cea63fe FOREIGN KEY (group_id) REFERENCES auth_group(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_instancja_miejsca_id_miejsca_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_instancja_miejsca
    ADD CONSTRAINT kinorezerwacja_instancja_miejsca_id_miejsca_fkey FOREIGN KEY (id_miejsca) REFERENCES kinorezerwacja_miejsce(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_instancja_miejsca_id_seansu_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_instancja_miejsca
    ADD CONSTRAINT kinorezerwacja_instancja_miejsca_id_seansu_fkey FOREIGN KEY (id_seansu) REFERENCES kinorezerwacja_seans(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_limit_rezerwacji_id_rangi_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_limit_rezerwacji
    ADD CONSTRAINT kinorezerwacja_limit_rezerwacji_id_rangi_fkey FOREIGN KEY (id_rangi) REFERENCES kinorezerwacja_ranga(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_miejsce_id_sali_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_miejsce
    ADD CONSTRAINT kinorezerwacja_miejsce_id_sali_fkey FOREIGN KEY (id_sali) REFERENCES kinorezerwacja_sala(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_mozliwy_bilet_id_seansu_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_mozliwy_bilet
    ADD CONSTRAINT kinorezerwacja_mozliwy_bilet_id_seansu_fkey FOREIGN KEY (id_seansu) REFERENCES kinorezerwacja_seans(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_mozliwy_bilet_id_typu_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_mozliwy_bilet
    ADD CONSTRAINT kinorezerwacja_mozliwy_bilet_id_typu_fkey FOREIGN KEY (id_typu) REFERENCES kinorezerwacja_typ_biletu(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_ranga_klienta_id_klienta_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_ranga_klienta
    ADD CONSTRAINT kinorezerwacja_ranga_klienta_id_klienta_fkey FOREIGN KEY (id_klienta) REFERENCES kinorezerwacja_klient(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_ranga_klienta_id_rangi_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_ranga_klienta
    ADD CONSTRAINT kinorezerwacja_ranga_klienta_id_rangi_fkey FOREIGN KEY (id_rangi) REFERENCES kinorezerwacja_ranga(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_rezerwacja_id_instancji_miejsca_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_rezerwacja
    ADD CONSTRAINT kinorezerwacja_rezerwacja_id_instancji_miejsca_fkey FOREIGN KEY (id_instancji_miejsca) REFERENCES kinorezerwacja_instancja_miejsca(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_rezerwacja_id_klienta_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_rezerwacja
    ADD CONSTRAINT kinorezerwacja_rezerwacja_id_klienta_fkey FOREIGN KEY (id_klienta) REFERENCES kinorezerwacja_klient(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_rezerwacja_id_typu_biletu_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_rezerwacja
    ADD CONSTRAINT kinorezerwacja_rezerwacja_id_typu_biletu_fkey FOREIGN KEY (id_typu_biletu) REFERENCES kinorezerwacja_typ_biletu(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_sala_id_budynku_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_sala
    ADD CONSTRAINT kinorezerwacja_sala_id_budynku_fkey FOREIGN KEY (id_budynku) REFERENCES kinorezerwacja_budynek(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_seans_id_filmu_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_seans
    ADD CONSTRAINT kinorezerwacja_seans_id_filmu_fkey FOREIGN KEY (id_filmu) REFERENCES kinorezerwacja_film(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: kinorezerwacja_seans_id_sali_fkey; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY kinorezerwacja_seans
    ADD CONSTRAINT kinorezerwacja_seans_id_sali_fkey FOREIGN KEY (id_sali) REFERENCES kinorezerwacja_sala(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: user_id_refs_id_7ceef80f; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_user_groups
    ADD CONSTRAINT user_id_refs_id_7ceef80f FOREIGN KEY (user_id) REFERENCES auth_user(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: user_id_refs_id_dfbab7d; Type: FK CONSTRAINT; Schema: public; Owner: kinor
--

ALTER TABLE ONLY auth_user_user_permissions
    ADD CONSTRAINT user_id_refs_id_dfbab7d FOREIGN KEY (user_id) REFERENCES auth_user(id) DEFERRABLE INITIALLY DEFERRED;


--
-- Name: public; Type: ACL; Schema: -; Owner: postgres
--

REVOKE ALL ON SCHEMA public FROM PUBLIC;
REVOKE ALL ON SCHEMA public FROM postgres;
GRANT ALL ON SCHEMA public TO postgres;
GRANT ALL ON SCHEMA public TO PUBLIC;


--
-- PostgreSQL database dump complete
--

